{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d7ac40dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from openai import OpenAI\n",
    "from dotenv import load_dotenv\n",
    "import gradio as gr\n",
    "import io\n",
    "import sys \n",
    "import subprocess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f0737df3",
   "metadata": {},
   "outputs": [],
   "source": [
    "load_dotenv(override=True)\n",
    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
    "ds_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
    "grok_api_key = os.getenv('GROK_API_KEY')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "834d1fa7",
   "metadata": {},
   "outputs": [],
   "source": [
    "MODEL_MAP = {\n",
    "    \"GPT\": {\n",
    "        \"model\": \"gpt-4o-mini\",\n",
    "        \"key\": openai_api_key,\n",
    "        \"endpoint\": \"https://api.openai.com/v1\",\n",
    "    },\n",
    "    \"CLAUDE_3_5_SONNET\": {\n",
    "        \"model\": \"claude-3-5-sonnet-20240620\",\n",
    "        \"key\": anthropic_api_key,\n",
    "        \"endpoint\": \"https://api.anthropic.com/v1\"\n",
    "    },\n",
    "    \"Grok\": {\n",
    "        \"model\": \"grok-beta\",\n",
    "        \"key\": grok_api_key,\n",
    "        \"endpoint\": \"https://api.grok.com/v1\"\n",
    "    },   \n",
    "   \"DeepSeek\": {\n",
    "        \"model\": \"deepseek-coder\",\n",
    "        \"key\": ds_api_key,\n",
    "        \"endpoint\": \"https://api.deepseek.com/v1\",\n",
    "    },\n",
    "    \"Google\": {\n",
    "        \"model\": \"gemini-2.0-flash-exp\",\n",
    "        \"key\": google_api_key,\n",
    "        \"endpoint\": \"https://generativelanguage.googleapis.com/v1beta/openai\"\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87d0508f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PortCode:\n",
    "    def __init__(self, progress=None, model_name=MODEL_MAP[\"GPT\"]):\n",
    "        self.progress = progress\n",
    "        self.model_deets = model_name\n",
    "        self.model = OpenAI(\n",
    "            api_key=model_name[\"key\"],\n",
    "            base_url=model_name[\"endpoint\"]\n",
    "        )\n",
    "        self.cpp_code = \"\"\n",
    "        \n",
    "    def update_progress(self, value, desc=\"\"):\n",
    "        if self.progress:\n",
    "            self.progress(value, desc=desc)\n",
    "        \n",
    "    def port_python_to_cpp(self, python_code):\n",
    "        self.update_progress(0.3, desc=\"Converting Python to C++...\")\n",
    "        \n",
    "        system_prompt = \"\"\"\n",
    "        Your task is to convert Python code into high performance C++ code.\n",
    "        Respond only with C++ code. Do not provide any explanation other than occasional comments.\n",
    "        The C++ response needs to produce an identical output in the fastest possible time.\n",
    "        \"\"\"\n",
    "        \n",
    "        user_prompt = f\"\"\"\n",
    "        Port this Python code to C++ with the fastest possible implementation that produces identical output in the least time.\n",
    "        Respond only with C++ code.\n",
    "        Python code to port:\n",
    "\n",
    "        ```python\n",
    "        {python_code}\n",
    "        ```\n",
    "        \"\"\"\n",
    "        \n",
    "        messages = [\n",
    "            {\"role\": \"system\", \"content\": system_prompt},\n",
    "            {\"role\": \"user\", \"content\": user_prompt}\n",
    "        ]\n",
    "        \n",
    "        try:\n",
    "            response = self.model.chat.completions.create(\n",
    "                model=self.model_deets[\"model\"],\n",
    "                messages=messages\n",
    "            )\n",
    "            \n",
    "            cpp_code = response.choices[0].message.content\n",
    "            cpp_code = cpp_code.replace('```cpp', '').replace('```', '').strip()\n",
    "            \n",
    "            self.cpp_code = cpp_code\n",
    "            \n",
    "            self.update_progress(1.0, desc=\"Conversion complete!\")\n",
    "            return cpp_code\n",
    "            \n",
    "        except Exception as e:\n",
    "            error_msg = f\"Error converting code: {str(e)}\"\n",
    "            self.update_progress(1.0, desc=\"Conversion failed!\")\n",
    "            return error_msg\n",
    "    \n",
    "    def run_python_code(self, python_code):\n",
    "        self.update_progress(0.1, desc=\"Running Python code...\")\n",
    "        \n",
    "        globals_dict = {\"__builtins__\": __builtins__}\n",
    "        buffer = io.StringIO()\n",
    "        old_stdout = sys.stdout\n",
    "        sys.stdout = buffer\n",
    "        \n",
    "        try:\n",
    "            exec(python_code, globals_dict)\n",
    "            output = buffer.getvalue()\n",
    "            self.update_progress(1.0, desc=\"Python execution complete!\")\n",
    "        except Exception as e:\n",
    "            output = f\"Error: {e}\"\n",
    "            self.update_progress(1.0, desc=\"Python execution failed!\")\n",
    "        finally:\n",
    "            sys.stdout = old_stdout\n",
    "        \n",
    "        return output\n",
    "    \n",
    "    def compile_cpp(self, cpp_code=None):\n",
    "        if cpp_code is None:\n",
    "            cpp_code = self.cpp_code\n",
    "            \n",
    "        if not cpp_code:\n",
    "            return \"No C++ code to compile. Please convert Python code first.\"\n",
    "            \n",
    "        self.update_progress(0.5, desc=\"Compiling C++ code...\")\n",
    "        \n",
    "        with open(\"main.cpp\", \"w\") as f:\n",
    "            f.write(cpp_code)\n",
    "        \n",
    "        compile_command = [\n",
    "            \"clang++\", \"-std=c++17\", \"-Ofast\", \"-mcpu=native\", \n",
    "            \"-flto=thin\", \"-fvisibility=hidden\", \"-DNDEBUG\", \n",
    "            \"main.cpp\", \"-o\", \"main\"\n",
    "        ]\n",
    "        \n",
    "        try:\n",
    "            subprocess.run(compile_command, check=True, text=True, capture_output=True)\n",
    "            self.update_progress(1.0, desc=\"C++ compilation complete!\")\n",
    "            return \"Compilation successful!\"\n",
    "            \n",
    "        except subprocess.CalledProcessError as e:\n",
    "            error_msg = f\"Compilation error: {e.stderr}\"\n",
    "            self.update_progress(1.0, desc=\"C++ compilation failed!\")\n",
    "            return error_msg\n",
    "        except Exception as e:\n",
    "            error_msg = f\"Error: {str(e)}\"\n",
    "            self.update_progress(1.0, desc=\"C++ compilation failed!\")\n",
    "            return error_msg\n",
    "    \n",
    "    def run_cpp(self):\n",
    "        self.update_progress(0.1, desc=\"Running C++ code...\")\n",
    "        \n",
    "        run_command = [\"./main\"]\n",
    "        \n",
    "        try:\n",
    "            if not os.path.exists(\"./main\"):\n",
    "                return \"No compiled executable found. Please compile C++ code first.\"\n",
    "            \n",
    "            run_result = subprocess.run(run_command, check=True, text=True, capture_output=True)\n",
    "            print(\"hello .....\")\n",
    "            self.update_progress(1.0, desc=\"C++ execution complete!\")\n",
    "            return run_result.stdout\n",
    "            \n",
    "        except subprocess.CalledProcessError as e:\n",
    "            error_msg = f\"Runtime error: {e.stderr}\"\n",
    "            self.update_progress(1.0, desc=\"C++ execution failed!\")\n",
    "            return error_msg\n",
    "        except Exception as e:\n",
    "            error_msg = f\"Error: {str(e)}\"\n",
    "            self.update_progress(1.0, desc=\"C++ execution failed!\")\n",
    "            return error_msg\n",
    "    \n",
    "    def compile_and_run_cpp(self, cpp_code=None):\n",
    "        \"\"\"Compile and run C++ code in one step\"\"\"\n",
    "        if cpp_code is None:\n",
    "            cpp_code = self.cpp_code\n",
    "            \n",
    "        if not cpp_code:\n",
    "            return \"No C++ code to compile and run. Please convert Python code first.\"\n",
    "            \n",
    "        compile_result = self.compile_cpp(cpp_code)\n",
    "        if \"error\" in compile_result.lower():\n",
    "            return compile_result\n",
    "        \n",
    "        return self.run_cpp()\n",
    "    \n",
    "    def get_cpp_code(self):\n",
    "        \"\"\"Get the stored C++ code\"\"\"\n",
    "        return self.cpp_code\n",
    "    \n",
    "    def set_cpp_code(self, cpp_code):\n",
    "        \"\"\"Manually set C++ code\"\"\"\n",
    "        self.cpp_code = cpp_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "4680573d",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Interface:\n",
    "    def __init__(self):\n",
    "        self.port_code = PortCode(gr.Progress())\n",
    "        \n",
    "    def create_interface(self):\n",
    "        with gr.Blocks(title=\"Code Porter\") as interface:\n",
    "            gr.Markdown(\"# 🚀 Python to C++ Converter\")\n",
    "            \n",
    "            with gr.Row():\n",
    "                python_input = gr.TextArea(label=\"Python Code\", lines=15)\n",
    "                cpp_output = gr.TextArea(label=\"C++ Code\", lines=15, interactive=False)\n",
    "            \n",
    "            with gr.Row():\n",
    "                python_result = gr.TextArea(label=\"Python Output\", lines=4, interactive=False)\n",
    "                cpp_result = gr.TextArea(label=\"C++ Output\", lines=4, interactive=False)\n",
    "            \n",
    "            with gr.Row():\n",
    "                run_python_btn = gr.Button(\"Run Python\")\n",
    "                run_cpp_btn = gr.Button(\"Run C++\")\n",
    "            \n",
    "            with gr.Row():\n",
    "                model_dropdown = gr.Dropdown(MODEL_MAP.keys(), value=\"GPT\", label=\"Model\")\n",
    "            \n",
    "            with gr.Row():\n",
    "                convert_btn = gr.Button(\"Convert\", variant=\"primary\")\n",
    "            \n",
    "            # Events\n",
    "            convert_btn.click(self.convert_code, [python_input, model_dropdown], cpp_output)\n",
    "            run_python_btn.click(self.run_python, python_input, python_result)\n",
    "            run_cpp_btn.click(self.run_cpp, cpp_output, cpp_result)\n",
    "            model_dropdown.change(self.update_model, model_dropdown, None)\n",
    "        \n",
    "        return interface\n",
    "    \n",
    "    def convert_code(self, python_code, model_name):\n",
    "        self.port_code = PortCode(model_name=MODEL_MAP[model_name])\n",
    "        return self.port_code.port_python_to_cpp(python_code)\n",
    "    \n",
    "    def run_python(self, python_code):\n",
    "        return self.port_code.run_python_code(python_code)\n",
    "    \n",
    "    def run_cpp(self, cpp_code):\n",
    "        self.port_code.set_cpp_code(cpp_code)\n",
    "        return self.port_code.compile_and_run_cpp()\n",
    "    \n",
    "    def update_model(self, model_name):\n",
    "        self.port_code = PortCode(model_name=MODEL_MAP[model_name])\n",
    "    \n",
    "    def launch(self, inbrowser=False):\n",
    "        self.create_interface().launch(inbrowser=inbrowser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7ced6dc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* Running on local URL:  http://127.0.0.1:7906\n",
      "* To create a public link, set `share=True` in `launch()`.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div><iframe src=\"http://127.0.0.1:7906/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "I = Interface()\n",
    "I.launch()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
